Création de traitements de données avec Hive : Un guide complet pour des solutions basées sur les données

Dans le monde actuel axé sur les données, la capacité à traiter et analyser efficacement des ensembles de données massifs est cruciale pour les organisations de toutes tailles. Hive, un système d'entrepôt de données construit sur Apache Hadoop, fournit une solution puissante et évolutive pour le traitement du big data. Ce guide complet vous présentera les aspects clés de la création d'un traitement de données efficace avec Hive, de la configuration initiale aux techniques d'optimisation avancées. Il est conçu pour un public mondial, reconnaissant la diversité des parcours et des niveaux d'expertise.

Comprendre Hive et son rôle dans le Big Data

Apache Hive est conçu pour simplifier le processus d'interrogation et d'analyse de grands ensembles de données stockés dans Hadoop. Il permet aux utilisateurs d'interroger les données à l'aide d'un langage de type SQL appelé HiveQL, ce qui facilite le travail avec le big data pour les personnes familières avec SQL. Hive transforme les requêtes en tâches MapReduce, les exécutant sur un cluster Hadoop. Cette architecture permet l'évolutivité et la tolérance aux pannes, la rendant idéale pour gérer des pétaoctets de données.

Caractéristiques clés de Hive :

• Langage de requête de type SQL (HiveQL) : Simplifie l'interrogation des données.
• Évolutivité : Tire parti des capacités de traitement distribué de Hadoop.
• Entreposage de données : Conçu pour le stockage et l'analyse de données structurées.
• Schema-on-Read : Permet une flexibilité dans la définition du schéma.
• Extensibilité : Prend en charge les fonctions et formats de données personnalisés.

Hive comble le fossé entre les complexités de Hadoop et la familiarité de SQL, rendant le big data accessible à un plus large éventail d'utilisateurs. Il excelle dans les processus ETL (Extract, Transform, Load), l'entreposage de données et l'analyse de requêtes ad-hoc.

Configurer votre environnement Hive

Avant de pouvoir commencer à traiter des données avec Hive, vous devez configurer votre environnement. Cela implique généralement d'installer Hadoop et Hive, de les configurer et de s'assurer qu'ils peuvent communiquer. Les étapes exactes varieront en fonction de votre système d'exploitation, de votre distribution Hadoop et de votre fournisseur de cloud (le cas échéant). Considérez les directives suivantes pour une applicabilité mondiale.

1. Prérequis

Assurez-vous d'avoir un cluster Hadoop fonctionnel. Cela implique généralement d'installer et de configurer Hadoop, y compris Java et SSH. Vous aurez également besoin d'un système d'exploitation approprié, tel que Linux (par exemple, Ubuntu, CentOS), macOS ou Windows. Les options basées sur le cloud comme Amazon EMR, Google Cloud Dataproc et Azure HDInsight peuvent simplifier ce processus.

2. Installation et Configuration

Téléchargez la distribution Hive depuis le site web d'Apache ou le gestionnaire de paquets de votre distribution Hadoop. Installez Hive sur une machine dédiée ou un nœud de votre cluster Hadoop. Configurez Hive en modifiant le fichier `hive-site.xml`. Les configurations clés incluent :

• `hive.metastore.uris` : Spécifie l'URI du Metastore de Hive (généralement une base de données comme MySQL ou PostgreSQL).
• `hive.metastore.warehouse.dir` : Définit l'emplacement du répertoire de l'entrepôt Hive (où vos données sont stockées).
• `hive.exec.scratchdir` : Spécifie le répertoire temporaire pour les fichiers de travail.

Exemple (Simplifié) :

            <property>
 <name>hive.metastore.uris</name>
 <value>thrift://<metastore_host>:9083</value>
</property>

<property>
 <name>hive.metastore.warehouse.dir</name>
 <value>/user/hive/warehouse</value>
</property>

            

              
                Copy
              
            
          

3. Configuration du Metastore

Le Metastore de Hive stocke les métadonnées de vos tables, partitions et autres structures de données. Vous devez choisir une base de données pour servir de metastore (par exemple, MySQL, PostgreSQL ou Derby). Si vous choisissez MySQL, configurez-le avec les privilèges utilisateur appropriés. Configurez Hive pour qu'il pointe vers la base de données du metastore en utilisant les propriétés de `hive-site.xml`.

4. Démarrer Hive

Démarrez le service Metastore de Hive, suivi de l'interface de ligne de commande (CLI) de Hive ou du client Beeline (une CLI plus avancée). Vous pouvez également utiliser HiveServer2 pour permettre la connectivité JDBC/ODBC à partir d'outils tels que Tableau, Power BI et d'autres plateformes d'analyse.

Par exemple, pour démarrer la CLI de Hive :

            hive
            

              
                Copy
              
            
          

Chargement des données et définition du schéma

Une fois votre environnement Hive configuré, l'étape suivante consiste à charger vos données et à définir le schéma. Hive prend en charge divers formats de données et offre des options flexibles pour définir vos structures de données. Tenez compte des formats de données internationaux, tels que les fichiers CSV qui utilisent des délimiteurs différents selon l'emplacement.

1. Formats de données pris en charge par Hive

Hive prend en charge plusieurs formats de données, notamment :

• Fichiers texte : (CSV, TSV, texte brut) - Couramment utilisés et faciles à gérer.
• Fichiers Séquence (Sequence Files) : Le format binaire de Hadoop, optimisé pour le stockage et la récupération des données.
• ORC (Optimized Row Columnar) : Un format de stockage en colonnes hautement optimisé, qui offre des performances et une compression de données supérieures.
• Parquet : Un autre format orienté colonne, souvent utilisé pour l'entreposage de données et l'analyse.
• JSON : Pour stocker des données semi-structurées.

Choisissez le format en fonction de la structure de vos données, de vos exigences de performance et de vos besoins de stockage. ORC et Parquet sont souvent préférés pour leur efficacité.

2. Création de tables et définition de schémas

Utilisez l'instruction `CREATE TABLE` pour définir la structure de vos données. Cela implique de spécifier les noms de colonnes, les types de données et les délimiteurs. La syntaxe générale est :

            CREATE TABLE <table_name> (
 <column_name> <data_type>,
 ...
) 
ROW FORMAT DELIMITED
  FIELDS TERMINATED BY '	'
STORED AS TEXTFILE;
            

              
                Copy
              
            
          

Exemple :

            CREATE TABLE employees (
 employee_id INT,
 first_name STRING,
 last_name STRING,
 department STRING,
 salary DOUBLE
) 
ROW FORMAT DELIMITED
  FIELDS TERMINATED BY ','
STORED AS TEXTFILE;
            

              
                Copy
              
            
          

Dans cet exemple, nous créons une table nommée `employees` avec diverses colonnes et leurs types de données. Les clauses `ROW FORMAT DELIMITED` et `FIELDS TERMINATED BY ','` spécifient comment les données sont formatées dans les fichiers texte. Tenez compte de l'utilisation de différents délimiteurs en fonction de l'emplacement de votre source de données.

3. Chargement des données dans les tables Hive

Utilisez l'instruction `LOAD DATA` pour charger des données dans vos tables Hive. Vous pouvez charger des données à partir de fichiers locaux ou de HDFS. La syntaxe générale est :

            LOAD DATA LOCAL INPATH '<local_file_path>' INTO TABLE <table_name>;
            

              
                Copy
              
            
          

Ou pour charger depuis HDFS :

            LOAD DATA INPATH '<hdfs_file_path>' INTO TABLE <table_name>;
            

              
                Copy
              
            
          

Exemple :

            LOAD DATA LOCAL INPATH '/path/to/employees.csv' INTO TABLE employees;
            

              
                Copy
              
            
          

Cette commande charge les données du fichier `employees.csv` dans la table `employees`. Vous devez vous assurer que le format du fichier CSV est cohérent avec le schéma de la table.

4. Partitionnement de vos tables

Le partitionnement améliore les performances des requêtes en divisant une table en parties plus petites basées sur une ou plusieurs colonnes (par exemple, date, région). Cela permet à Hive de ne lire que les données pertinentes lors d'une interrogation. Le partitionnement est crucial pour les ensembles de données structurés par temps ou par lieu.

Pour créer une table partitionnée, utilisez la clause `PARTITIONED BY` dans l'instruction `CREATE TABLE`.

            CREATE TABLE sales (
 transaction_id INT,
 product_id INT,
 quantity INT,
 sale_date STRING
) 
PARTITIONED BY (year INT, month INT) 
ROW FORMAT DELIMITED
  FIELDS TERMINATED BY ',';
            

              
                Copy
              
            
          

Lors du chargement de données dans une table partitionnée, vous devez spécifier les valeurs de la partition :

            LOAD DATA LOCAL INPATH '/path/to/sales_2023_10.csv' INTO TABLE sales PARTITION (year=2023, month=10);
            

              
                Copy
              
            
          

Écrire des requêtes Hive efficaces (HiveQL)

HiveQL, le langage de type SQL pour Hive, vous permet d'interroger et d'analyser vos données. Maîtriser HiveQL est la clé pour extraire des informations précieuses de vos ensembles de données. Gardez toujours à l'esprit les types de données utilisés pour chaque colonne.

1. Instructions SELECT de base

Utilisez l'instruction `SELECT` pour récupérer des données des tables. La syntaxe générale est :

            SELECT <column_name(s)> FROM <table_name> WHERE <condition(s)>;
            

              
                Copy
              
            
          

Exemple :

            SELECT employee_id, first_name, last_name
FROM employees
WHERE department = 'Sales';
            

              
                Copy
              
            
          

2. Filtrer les données avec la clause WHERE

La clause `WHERE` filtre les données en fonction des conditions spécifiées. Utilisez des opérateurs de comparaison (par exemple, =, !=, <, >) et des opérateurs logiques (par exemple, AND, OR, NOT) pour construire vos critères de filtre. Considérez les implications des valeurs nulles et comment elles pourraient affecter les résultats.

Exemple :

            SELECT * FROM sales WHERE sale_date > '2023-01-01' AND quantity > 10;
            

              
                Copy
              
            
          

3. Agréger les données avec GROUP BY et HAVING

La clause `GROUP BY` regroupe les lignes ayant les mêmes valeurs dans une ou plusieurs colonnes en une ligne de résumé. La clause `HAVING` filtre les données groupées en fonction d'une condition. Les fonctions d'agrégation, telles que `COUNT`, `SUM`, `AVG`, `MIN` et `MAX`, sont utilisées en conjonction avec `GROUP BY`.

Exemple :

            SELECT department, COUNT(*) AS employee_count
FROM employees
GROUP BY department
HAVING employee_count > 5;
            

              
                Copy
              
            
          

4. Joindre des tables

Utilisez les clauses `JOIN` pour combiner des données de plusieurs tables sur la base d'une colonne commune. Hive prend en charge différents types de jointures, notamment `INNER JOIN`, `LEFT OUTER JOIN`, `RIGHT OUTER JOIN` et `FULL OUTER JOIN`. Soyez conscient de l'impact de l'ordre des jointures sur les performances.

Exemple :

            SELECT e.first_name, e.last_name, d.department_name
FROM employees e
JOIN departments d ON e.department = d.department_id;
            

              
                Copy
              
            
          

5. Utiliser les fonctions intégrées

Hive offre un riche ensemble de fonctions intégrées pour la manipulation de données, y compris des fonctions de chaîne, des fonctions de date et des fonctions mathématiques. Expérimentez avec ces fonctions pour voir comment elles fonctionnent et si des transformations pourraient être nécessaires.

Exemple (Fonction de chaîne) :

            SELECT UPPER(first_name), LOWER(last_name) FROM employees;
            

              
                Copy
              
            
          

Exemple (Fonction de date) :

            SELECT sale_date, YEAR(sale_date), MONTH(sale_date) FROM sales;
            

              
                Copy
              
            
          

Optimiser les requêtes Hive pour la performance

À mesure que vos ensembles de données s'agrandissent, la performance des requêtes devient critique. Plusieurs techniques peuvent améliorer de manière significative l'efficacité de vos requêtes Hive. L'efficacité de ces techniques dépendra de vos données, de la configuration de votre cluster et de la complexité de vos requêtes. Mesurez toujours avant et après la mise en œuvre de toute optimisation pour confirmer qu'elle apporte une valeur ajoutée.

1. Techniques d'optimisation des requêtes

• Partitionnement : Comme mentionné précédemment, le partitionnement de vos tables en fonction de colonnes pertinentes (par exemple, date, région) réduit la quantité de données balayées lors d'une requête.
• Bucketing : Le bucketing (ou mise en buckets) divise les données au sein d'une partition en unités plus petites et plus faciles à gérer. Cela peut améliorer les performances des requêtes, en particulier pour celles impliquant des jointures.
• Indexation : Hive prend en charge l'indexation sur certaines colonnes pour accélérer les requêtes. Cependant, la surcharge de l'indexation peut l'emporter sur les avantages dans toutes les situations.
• Vectorisation : Permet à Hive de traiter des lots de lignes à la fois, ce qui réduit l'utilisation du processeur et améliore les performances. Ceci est souvent activé par défaut dans les versions plus récentes.
• Analyse du plan de requête : Analysez le plan de requête à l'aide de la commande `EXPLAIN` pour comprendre comment Hive traite votre requête et identifier les goulots d'étranglement potentiels.

2. Format des données et optimisation du stockage

• Choisir le bon format de stockage : ORC et Parquet sont des formats de stockage en colonnes très efficaces qui offrent des avantages de performance significatifs par rapport aux fichiers texte.
• Compression des données : Utilisez des codecs de compression de données comme Snappy, Gzip ou LZO pour réduire l'espace de stockage et améliorer les performances des requêtes.
• Gestion de la taille des données : Assurez-vous de gérer des volumes de données que votre cluster peut gérer efficacement. Le partitionnement des données peut aider avec les grands ensembles de données.

3. Paramètres de configuration pour l'optimisation

Modifiez les paramètres de configuration de Hive pour optimiser l'exécution des requêtes. Certains paramètres importants incluent :

• `hive.exec.parallel` : Active l'exécution parallèle des tâches map et reduce.
• `hive.mapjoin.smalltable.filesize` : Contrôle la taille maximale des tables pouvant être utilisées dans les map joins (joindre de petites tables avec de plus grandes tables en mémoire).
• `hive.optimize.skewjoin` : Optimise les jointures impliquant des données asymétriques (données où certaines clés apparaissent beaucoup plus fréquemment que d'autres).
• `hive.compute.query.using.stats` : Tire parti des statistiques des tables pour créer de meilleurs plans d'exécution de requêtes.

Exemple (Configuration de l'exécution parallèle) :

            SET hive.exec.parallel=true;
            

              
                Copy
              
            
          

4. Optimisation basée sur les coûts (CBO)

La CBO est une technique d'optimisation avancée qui s'appuie sur les statistiques des tables pour générer des plans d'exécution de requêtes plus efficaces. Elle analyse la distribution des données, la taille des tables et d'autres facteurs pour déterminer la meilleure façon d'exécuter une requête. Activez la CBO en définissant :

            SET hive.cbo.enable=true;
            

              
                Copy
              
            
          

Rassemblez les statistiques de la table pour fournir les informations dont la CBO a besoin. Vous pouvez le faire en utilisant la commande suivante :

            ANALYZE TABLE <table_name> COMPUTE STATISTICS;
            

              
                Copy
              
            
          

Envisagez d'exécuter `ANALYZE TABLE <table_name> COMPUTE STATISTICS FOR COLUMNS <column_name1>,<column_name2>;` pour des statistiques de colonnes plus détaillées.

Techniques Hive avancées

Une fois que vous maîtrisez les bases, vous pouvez explorer les techniques Hive avancées pour gérer des scénarios de traitement de données complexes.

1. Fonctions définies par l'utilisateur (UDF)

Les UDF vous permettent d'étendre les fonctionnalités de Hive en écrivant des fonctions personnalisées en Java. C'est utile pour effectuer des transformations de données complexes ou intégrer Hive avec des systèmes externes. La création d'UDF nécessite des connaissances en programmation Java et peut grandement améliorer le traitement des données dans des tâches très spécifiques.

Étapes pour créer et utiliser une UDF :

1. Écrivez l'UDF en Java, en étendant la classe `org.apache.hadoop.hive.ql.udf.UDF`.
2. Compilez le code Java dans un fichier JAR.
3. Ajoutez le fichier JAR au classpath de Hive en utilisant la commande `ADD JAR`.
4. Créez l'UDF dans Hive en utilisant la commande `CREATE FUNCTION`, en spécifiant le nom de la fonction, le nom de la classe Java et le chemin du fichier JAR.
5. Utilisez l'UDF dans vos requêtes Hive.

Exemple (UDF simple) : Considérez cette UDF qui met une chaîne de caractères en majuscules.

            // Java UDF
import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;

public class Capitalize extends UDF {
 public Text evaluate(Text str) {
 if (str == null) {
 return null;
 }
 return new Text(str.toString().toUpperCase());
 }
}

            

              
                Copy
              
            
          

Compilez ceci dans un JAR (par exemple, `Capitalize.jar`) puis utilisez les commandes Hive suivantes.

            ADD JAR /path/to/Capitalize.jar;
CREATE FUNCTION capitalize AS 'Capitalize' USING JAR '/path/to/Capitalize.jar';
SELECT capitalize(first_name) FROM employees;
            

              
                Copy
              
            
          

2. Fonctions d'agrégation définies par l'utilisateur (UDAF)

Les UDAF effectuent des agrégations sur plusieurs lignes. Comme les UDF, vous écrivez les UDAF en Java. Elles fonctionnent en définissant une méthode `evaluate()` qui accepte les données d'entrée, et une méthode `iterate()`, `merge()`, et `terminatePartial()` pour le processus d'agrégation itératif.

3. Fonctions de génération de table définies par l'utilisateur (UDTF)

Les UDTF génèrent plusieurs lignes et colonnes à partir d'une seule ligne d'entrée. Elles sont plus complexes que les UDF et les UDAF, mais puissantes pour la transformation de données.

4. Partitionnement dynamique

Le partitionnement dynamique permet à Hive de créer automatiquement des partitions en fonction des valeurs des données. Cela simplifie le processus de chargement des données dans des tables partitionnées. Vous activez le partitionnement dynamique en définissant `hive.exec.dynamic.partition=true` et `hive.exec.dynamic.partition.mode=nonstrict`.

Exemple (Partitionnement dynamique) :

            SET hive.exec.dynamic.partition=true;
SET hive.exec.dynamic.partition.mode=nonstrict;

INSERT INTO TABLE sales_partitioned
PARTITION (year, month)
SELECT transaction_id, product_id, quantity, sale_date, year(sale_date), month(sale_date)
FROM sales_staging;
            

              
                Copy
              
            
          

5. Types de données complexes

Hive prend en charge des types de données complexes tels que les tableaux (arrays), les dictionnaires (maps) et les structures (structs), vous permettant de gérer des structures de données plus complexes directement dans Hive. Cela élimine le besoin de pré-traiter de tels types lors du chargement des données.

Exemple (Utilisation de Structs) :

            CREATE TABLE contacts (
 id INT,
 name STRING,
 address STRUCT<street:STRING, city:STRING, state:STRING, zip:INT>
);

            

              
                Copy
              
            
          

Bonnes pratiques pour le traitement avec Hive

Suivez ces bonnes pratiques pour assurer un traitement avec Hive efficace et maintenable.

1. Gouvernance et qualité des données

• Validation des données : Mettez en œuvre des contrôles de validation des données lors du chargement et du traitement pour garantir la qualité des données.
• Lignage des données : Suivez le lignage des données pour comprendre les origines et les transformations de vos données. Des outils comme Apache Atlas peuvent vous aider.
• Catalogue de données : Maintenez un catalogue de données pour documenter vos données, schémas et définitions de données.

2. Conception et optimisation des requêtes

• Comprenez vos données : Comprenez bien vos données avant d'écrire des requêtes.
• Optimisez les requêtes : Testez toujours vos requêtes et identifiez les goulots d'étranglement de performance à l'aide de la commande `EXPLAIN`.
• Utilisez le partitionnement et le bucketing : Mettez en œuvre des stratégies de partitionnement et de bucketing pour améliorer les performances des requêtes.
• Évitez les balayages de table complets : Utilisez les clauses `WHERE` et les partitions pour limiter la quantité de données balayées.
• Utilisez les jointures efficacement : Tenez compte de l'ordre des jointures et de la taille des tables impliquées. Utilisez `MAPJOIN` si possible et que les tables sont petites.
• Optimisez pour l'asymétrie des données : Gérez l'asymétrie des données (où certaines clés apparaissent beaucoup plus souvent que d'autres) en utilisant des techniques comme le salage (salting) ou les jointures pour données asymétriques (skew joins).

3. Gestion des ressources

• Surveillez les ressources du cluster : Surveillez l'utilisation des ressources de votre cluster Hadoop (CPU, mémoire, E/S disque) pour identifier les goulots d'étranglement.
• Ajustez l'allocation des ressources : Configurez les paramètres d'allocation des ressources de Hive (par exemple, mémoire, cœurs de CPU) en fonction de la charge de travail.
• Gérez la concurrence : Limitez le nombre de requêtes concurrentes pour éviter de surcharger le cluster.
• Systèmes de file d'attente : Utilisez des systèmes de gestion des ressources comme YARN pour gérer l'allocation des ressources.

4. Documentation et contrôle de version

• Documentez vos données et requêtes : Documentez vos schémas de données, requêtes et processus ETL pour assurer la clarté et la maintenabilité.
• Utilisez le contrôle de version : Stockez vos scripts et configurations Hive dans un système de contrôle de version (par exemple, Git) pour suivre les changements et faciliter la collaboration.
• Mettez en œuvre une stratégie de test : Créez une stratégie de test pour vous assurer que vos requêtes Hive se comportent comme prévu.

Solutions Hive basées sur le Cloud

De nombreux fournisseurs de cloud offrent des services Hive gérés, simplifiant le déploiement, la gestion et la mise à l'échelle. Ceux-ci incluent :

• Amazon EMR (Elastic MapReduce) : Un service Hadoop et Spark géré sur AWS.
• Google Cloud Dataproc : Un service Spark et Hadoop entièrement géré et évolutif sur Google Cloud Platform.
• Azure HDInsight : Un service Hadoop géré sur Microsoft Azure.

Ces services cloud éliminent le besoin de gérer l'infrastructure sous-jacente, réduisant la charge opérationnelle et vous permettant de vous concentrer sur l'analyse des données. Ils offrent également souvent une évolutivité rentable et des outils intégrés pour la surveillance et la gestion.

Dépannage des problèmes courants

Voici quelques problèmes courants liés à Hive et leurs solutions :

• Problèmes de performance des requêtes :
  • Solution : Utilisez la commande `EXPLAIN` pour analyser le plan de requête. Optimisez les schémas de table, utilisez le partitionnement, optimisez les jointures et configurez les paramètres d'optimisation de Hive. Examinez le plan de requête. Vérifiez les statistiques.
• Problèmes de connexion au Metastore :
  • Solution : Vérifiez que le serveur du Metastore est en cours d'exécution et accessible. Vérifiez votre configuration `hive-site.xml` pour l'URI correct du Metastore. Confirmez que le serveur du Metastore dispose des privilèges nécessaires. Vérifiez la connectivité réseau avec le serveur Metastore.
• Erreurs de mémoire insuffisante (Out-of-Memory) :
  • Solution : Augmentez la taille du tas Java (`-Xmx`) pour HiveServer2 ou la CLI Hive. Ajustez les paramètres de mémoire dans Hadoop et Hive (par exemple, `mapreduce.map.memory.mb`, `mapreduce.reduce.memory.mb`). Configurez l'allocation des ressources YARN pour gérer efficacement la mémoire.
• Erreurs de fichier non trouvé (File Not Found) :
  • Solution : Vérifiez que le chemin du fichier dans votre instruction `LOAD DATA` ou votre requête est correct. Assurez-vous que le fichier existe dans HDFS ou votre système de fichiers local (selon la façon dont vous chargez les données). Vérifiez les permissions d'accès au fichier.
• Erreurs de partitionnement :
  • Solution : Vérifiez les types de données et le format de vos colonnes de partition. Vérifiez que les colonnes de partition sont correctement spécifiées dans les instructions `CREATE TABLE` et `LOAD DATA`.

Conclusion

La création d'un traitement de données efficace avec Hive implique une compréhension approfondie de l'architecture de Hive, des formats de stockage de données, des techniques d'optimisation des requêtes et des meilleures pratiques. En suivant les directives de ce guide complet, vous pouvez construire une solution de traitement de données robuste et évolutive capable de gérer de grands ensembles de données. De la configuration initiale à l'optimisation avancée et au dépannage, ce guide vous fournit les connaissances et les compétences nécessaires pour exploiter la puissance de Hive pour des aperçus basés sur les données dans un paysage mondial. L'apprentissage continu et l'expérimentation vous permettront d'extraire une valeur maximale de vos données.